home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung / Power-Programmierung (Tewi)(1994).iso / magazine / drdobbs / 1990 / 10 / schatz.asc < prev    next >
Text File  |  1990-08-16  |  4KB  |  223 lines
  1. _UNRAVELING OPTIMIZATION IN MICROSOFT C 6.0_
  2. by Bruce D. Schatzman
  3.  
  4. [LISTING ONE]
  5.  
  6. #include <stdio.h>
  7. long area[3];
  8. void compute_areas(void);
  9.  
  10. main()
  11. {
  12.     int i;
  13.     extern long area[3];
  14.     compute_areas();
  15.     for(i = 0; i <= 2; i++) printf("The approximate area of function %d is %ld\n", i, area[i]);
  16. }
  17.  
  18. void compute_areas(void)
  19. {     long temp, y0[100], y1[100], y2[100];
  20.     extern long area[3];
  21.     int i, k, a, b, c, d, n, m, j;
  22.  
  23.     a = 2; b = 5; c = 1; d = 3;
  24.     area[0] = area[1] = area[2] = temp = 0;
  25.  
  26.        /*  compute 100 initial y values for all functions and approximate area under curves. Do this 100 times. */
  27.     for (i = 0; i <= 99; i++) {
  28.         for (j = 0; j <= 99; j++) {
  29.             n = j-1;
  30.             m = j+1;
  31.             y0[j] = a*j*n + 48*j - (c+d);
  32.             y1[j] = d*(j+10) + a*b;
  33.             y2[j] = c*j*m + 73*j*j + n;
  34.         }
  35.     }
  36. /* add a*b+c+d to all y values. Do this 100 times. */
  37.     for (i = 0; i <= 99; i++) {
  38.         for (j = 0; j <= 99; j++) {
  39.             y0[j] += a*b+c+d;
  40.             y1[j] += a*b+c+d;
  41.             y2[j] += a*b+c+d;
  42.         }
  43.     }
  44.  
  45. /* bubblesort each array */
  46.     for (i = 0; i <= 99; i++) {
  47.         for (k = 99; k >= 1; k--) {
  48.             if (y0[k-1] > y0[k]) {
  49.                 temp = y0[k];
  50.                 y0[k] = y0[k-1];
  51.                 y0[k-1] = temp;
  52.             }
  53.             if (y1[k-1] > y1[k]) {
  54.                 temp = y1[k];
  55.                 y1[k] = y1[k-1];è                y1[k-1] = temp;
  56.             }
  57.             if (y2[k-1] > y2[k]) {
  58.                 temp = y2[k];
  59.                 y2[k] = y2[k-1];
  60.                 y2[k-1] = temp;
  61.             }
  62.         }
  63.     }
  64.  
  65.     /*  now compute areas */
  66.     for (j = 0; j <= 99; j++) {
  67.         area[0] += y0[j];
  68.         area[1] += y1[j];
  69.         area[2] += y2[j];
  70.     }
  71.  
  72.     return;
  73.    }
  74.  
  75.  
  76. [LISTING TWO]
  77.  
  78. #include <stdio.h>
  79. long area[3];
  80. void compute_areas(void);
  81.  
  82. main()
  83. {
  84.     int i;
  85.     extern long area[3];
  86.     compute_areas();
  87.     for(i = 0; i <= 2; i++) printf("The approximate area of function %d is %ld\n", i, area[i]);
  88.  
  89. }
  90. void compute_areas(void)
  91. {     long temp, y0[100], y1[100], y2[100];
  92.     extern long area[3];
  93.     int i, k, a, b, c, d, n, m, j;
  94.  
  95.     a = 2; b = 5; c = 1; d = 3;
  96.     area[0] = area[1] = area[2] = temp = 0;
  97.  
  98.  /*  compute 100 initial y values for all functions and approximate area under curves. Do this 100 times. */
  99.     for (i = 0; i <= 99; i++) {
  100.         for (j = 0; j <= 99; j++) {
  101.             n = j-1;
  102.             m = j+1;
  103.             y0[j] = a*j*n + 48*j - 4;
  104.             y1[j] = d*j +40;
  105.             y2[j] = c*j*j*m - 73*j*j;
  106.         }
  107.     }
  108.  
  109. /* add 14 to all y values. Do this 100 times. */è    for (i = 0; i <= 99; i++) {
  110.         for (j = 0; j <= 99; j++) {
  111.             y0[j] += 14;
  112.             y1[j] += 14;
  113.             y2[j] += 14;
  114.         }
  115.     }
  116.  
  117. /* bubblesort each array */
  118.     for (i = 0; i <= 99; i++) {
  119.         for (k = 99; k >= 1; k--) {
  120.             if (y0[k-1] > y0[k]) {
  121.                 temp = y0[k];
  122.                 y0[k] = y0[k-1];
  123.                 y0[k-1] = temp;
  124.             }
  125.             if (y1[k-1] > y1[k]) {
  126.                 temp = y1[k];
  127.                 y1[k] = y1[k-1];
  128.                 y1[k-1] = temp;
  129.             }
  130.             if (y2[k-1] > y2[k]) {
  131.                 temp = y2[k];
  132.                 y2[k] = y2[k-1];
  133.                 y2[k-1] = temp;
  134.             }
  135.         }
  136.     }
  137.  
  138.     /*  now compute areas */
  139.     for (j = 0; j <= 99; j++) {
  140.         area[0] += y0[j];
  141.         area[1] += y1[j];
  142.         area[2] += y2[j];
  143.     }
  144.  
  145.     return;
  146. }               
  147.  
  148.  
  149. [LISTING THREE]
  150.  
  151. #include <stdio.h>
  152. long area[3];
  153. void compute_areas(void);
  154.  
  155. main()
  156. {
  157.     int i;
  158.     extern long area[3];
  159.     compute_areas();
  160.     for(i = 0; i <= 2; i++) printf("The approximate area of function %d is %ld\n", i, area[i]);
  161. }
  162.  
  163. void compute_areas(void)è{     long temp, y0[100], y1[100], y2[100];
  164.     extern long area[3];
  165.     int i, k, j;
  166.  
  167.     area[0] = area[1] = area[2] = temp = 0;
  168.  
  169.  /*  compute 100 initial y values for all functions and approximate area under curves. Do this 100 times. */
  170.     for (i = 0; i <= 99; i++) {
  171.         for (j = 0; j <= 99; j++) {
  172.             y0[j] = 2*j*j - 50*j +10;
  173.             y1[j] = 3*j + 54;
  174.             y2[j] = j*j*j - 72*j + 14;
  175.         }
  176.     }
  177.  
  178. /* bubblesort each array */
  179.     for (i = 0; i <= 99; i++) {
  180.         for (k = 99; k >= 1; k--) {
  181.             if (y0[k-1] > y0[k]) {
  182.                 temp = y0[k];
  183.                 y0[k] = y0[k-1];
  184.                 y0[k-1] = temp;
  185.             }
  186.             if (y1[k-1] > y1[k]) {
  187.                 temp = y1[k];
  188.                 y1[k] = y1[k-1];
  189.                 y1[k-1] = temp;
  190.             }
  191.             if (y2[k-1] > y2[k]) {
  192.                 temp = y2[k];
  193.                 y2[k] = y2[k-1];
  194.                 y2[k-1] = temp;
  195.             }
  196.         }
  197.     }
  198.  
  199.     /*  now compute areas */
  200.     for (j = 0; j <= 99; j++) {
  201.         area[0] += y0[j];
  202.         area[1] += y1[j];
  203.         area[2] += y2[j];
  204.     }
  205.  
  206.     return;
  207. }
  208.  
  209.  
  210. [Example 1.  ]
  211.  
  212. void main(void)
  213. {
  214.     int  x, y, *p;
  215.     p = &x;
  216.     x = 1; y = 2; z = 6
  217.     for(k = 1; k <= 100; k++) {è            k += x + y + z;
  218.             *p = k;
  219.     }
  220. )
  221.  
  222.  
  223.